// 1. 基础计算题 - 数组求和
// const numbers = [1, 2, 3, 4, 5];
// function sum(arr) {
//    return arr.reduce((total,num)=>{
//        return total + num;
//    },0)
// }
// console.log(sum(numbers));

// 2. 数据转换题 - 数组转对象
// const fruits = ['apple', 'banana', 'orange']; // 使用 reduce 将数组转换为：{0: 'apple', 1: 'banana', 2: 'orange'}
// function objToArr(arr) {
//     return arr.reduce((res,obj,index)=>{
//         res[index] = obj;
//         return res;
//     },{});
// }
// console.log(objToArr(fruits));

// 3. 统计题 - 字符频率统计
// const text = "hello world"; // 输出：{h:1, e:1, l:3, o:2, ' ':1, w:1, r:1, d:1}
// function getStrCount(str) {
//     const strArr = str.split('');
//     return strArr.reduce((res,str)=>{
//         if(res[str]) {
//             res[str]++;
//         }else {
//            res[str] = 1;
//         }
//         return res;
//     },{});
// }
// console.log(getStrCount(text));

// 4. 数据处理题 - 扁平化并去重
// const nestedArrays = [[1, 2, [6,5],3], [2, 3, 4], [5, 6]]; // 输出：[1, 2, 3, 4, 5, 6]
// function flatArr(arr) {
//     const result =  arr.reduce((res,item)=>{
//        if(Array.isArray(item)) {
//           return res.concat(flatArr(item));
//        }else {
//           return res.concat(item);
//        }
//     },[]);
//     return Array.from(new Set(result));
// }
// console.log(flatArr(nestedArrays));

// 5. 复杂数据处理 - 分组统计
// const students = [
//   { name: 'Alice', grade: 'A', subject: 'Math' },
//   { name: 'Bob', grade: 'B', subject: 'Math' },
//   { name: 'Charlie', grade: 'A', subject: 'English' },
//   { name: 'David', grade: 'A', subject: 'Math' }
// ]; // 输出：{ Math: 2, English: 1 } 统计每个学科的A等生数量

// function groupByStudents(arr,key,fun) {
//     return arr.reduce((res,obj)=>{
//         const objKey = obj[key];
//         if(res[objKey] && fun(obj)) {
//             res[objKey]++;
//         }else {
//            res[objKey] = 1;
//         }
//         return res;
//     },{});
// }
// console.log(groupByStudents(students,'subject',(obj)=>obj.grade === 'A'));

// 6. 进阶题 - 函数组合
// const functions = [
//   x => x + 1,
//   x => x * 2,
//   x => x - 3,
//   x => x * x
// ]; // 输入 2，执行流程：2+1=3 → 3*2=6 → 6-3=3 → 3*3=9

// function caculate(arr,initVal) {
//     return arr.reduce((res,fn)=>{
//         const fun = function(res) {
//             return fn(res)
//         }
//         return fun(res);
//     },initVal)
// }
// console.log(caculate(functions,2));

// 1. 基础去重 - 数字数组
// const numbers = [1, 2, 2, 3, 4, 4, 5, 5, 5];
// function uniqueArr(arr) {
//     return arr.reduce((res,item)=>{
//         if(!res.includes(item)) {
//             res.push(item);
//         }
//         return res;
//     },[]);
// }
// console.log(uniqueArr(numbers));

// 2. 对象数组去重 - 根据属性去重
// const users = [
//   { id: 1, name: 'Alice' },
//   { id: 2, name: 'Bob' },
//   { id: 1, name: 'Alice' },
//   { id: 3, name: 'Charlie' },
//   { id: 2, name: 'Bob' }
// ]; // 根据 id 属性去重

// function uniqueArr2(arr,key) {
//     const result = {};
//     return arr.reduce((res,obj)=>{
//         const objKey = obj[key];
//         if(!result[objKey]){
//           result[objKey] = obj;
//           res.push(obj);
//         }
//         return res;
//     },[]);
// }
// console.log(uniqueArr2(users,'id'));

// 3. 多条件去重 - 复合键去重
// const orders = [
//   { product: 'apple', store: 'A', quantity: 2 },
//   { product: 'banana', store: 'B', quantity: 3 },
//   { product: 'apple', store: 'A', quantity: 1 },
//   { product: 'orange', store: 'A', quantity: 4 },
//   { product: 'banana', store: 'B', quantity: 2 }
// ]; // 根据 product 和 store 组合去重（保留第一次出现的）预期结果: 每个产品和店铺组合只出现一次

// function uniqueArr3(arr,fun) {
//     const result = {};
//     return arr.reduce((res,obj)=>{
//         const objKey = fun(obj);
//         if(!result[objKey]) {
//           result[objKey] = obj;
//           res.push(obj);
//         }
//         return res;
//     },[]);
// }

// console.log(uniqueArr3(orders,(obj)=>(`${obj.product}-${obj.store}`)));

// 4. 嵌套数组去重 - 多维度数组 不会
// const complexArray = [
//   [1, 2, 3],
//   [2, 3, 4],
//   [1, 2, 3], // 重复
//   [3, 4, 5],
//   [2, 3, 4]  // 重复
// ]; // 子数组去重（比较数组内容） // 预期结果: 唯一的子数组

// function uniqueArr4(arr) {
//     const result = new Set();
//     return arr.reduce((res,item)=>{
//        const key = JSON.stringify(item);
//        if(!result.has(key)) {
//            result.add(key,item);
//            res.push(item); 
//        }
//        return res;
//     },[]);
// }
// console.log(uniqueArr4(complexArray));

// 5. 统计并去重 - 带频率统计的去重
const items = ["apple", "banana", "apple", "orange", "banana", "apple"];
// function uniqueArr5(arr) {
//   const count = arr.reduce((res, obj) => {
//     if (res[obj]) {
//       res[obj]++;
//     } else {
//       res[obj] = 1;
//     }
//     return res;
//   }, {});
//   const unique = arr.reduce((res, item) => {
//     if (!res.includes(item)) {
//       res.push(item);
//     }
//     return res;
//   }, []);
//   return {
//     unique,
//     count,
//   };
// }
// console.log(uniqueArr5(items));
// function uniqueArr5Plus(arr) {
//     return arr.reduce((res,item)=>{
//         if(res.count[item]) {
//             res.count[item]++;
//         }else {
//             res.count[item] = 1;
//         }
//         if (!res.unique.includes(item)) {
//             res.unique.push(item);
//         }
//         return res;
//     },{unique:[],count: {}})
// }
// console.log(uniqueArr5Plus(items));

// 6. 高级去重 - 自定义比较函数
const data = [
  { x: 1, y: 2 },
  { x: 2, y: 3 },
  { x: 1, y: 2 }, // 重复（x和y都相同）
  { x: 1, y: 3 }, // 不重复
  { x: 2, y: 3 }  // 重复
]; // 比较函数: (a, b) => a.x === b.x && a.y === b.y

function uniqueArr6(arr,fun) {
    return arr.reduce((res,current)=>{
        // 检查是否已存在（使用自定义比较函数）任意一个对象比较，所以用some
        const isDuplicate = res.some(item => fun(item, current));
        console.log('isDuplicate',isDuplicate);
        if (!isDuplicate) {
            res.push(current);
        }
        return res;
    },[]);
}
const result = uniqueArr6(data, (a, b) => a.x === b.x && a.y === b.y);
console.log(result);
